/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.io.output;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import junit.framework.TestCase;
/**
* Basic unit tests for the alternative ByteArrayOutputStream implementation.
*
* @author <a href="mailto:jeremias@apache.org">Jeremias Maerki</a>
*/
public class ByteArrayOutputStreamTestCase extends TestCase {
private static final byte[] DATA;
static {
DATA = new byte[64];
for (byte i = 0; i < 64; i++) {
DATA[i] = i;
}
}
public ByteArrayOutputStreamTestCase(String name) {
super(name);
}
private int writeData(ByteArrayOutputStream baout,
java.io.ByteArrayOutputStream ref,
int count) throws IOException {
if (count > DATA.length) {
throw new IllegalArgumentException("Requesting too many bytes");
}
if (count == 0) {
baout.write(100);
ref.write(100);
return 1;
} else {
baout.write(DATA, 0, count);
ref.write(DATA, 0, count);
return count;
}
}
private int writeData(ByteArrayOutputStream baout,
java.io.ByteArrayOutputStream ref,
int[] instructions) throws IOException {
int written = 0;
for (int i = 0; i < instructions.length; i++) {
written += writeData(baout, ref, instructions[i]);
}
return written;
}
private static boolean byteCmp(byte[] src, byte[] cmp) {
for (int i = 0; i < cmp.length; i++) {
if (src[i] != cmp[i]) {
return false;
}
}
return true;
}
private void checkByteArrays(byte[] expected, byte[] actual) {
if (expected.length != actual.length) {
fail("Resulting byte arrays are not equally long");
}
if (!byteCmp(expected, actual)) {
fail("Resulting byte arrays are not equal");
}
}
private void checkStreams(
ByteArrayOutputStream actual,
java.io.ByteArrayOutputStream expected) {
assertEquals("Sizes are not equal", expected.size(), actual.size());
byte[] buf = actual.toByteArray();
byte[] refbuf = expected.toByteArray();
checkByteArrays(buf, refbuf);
}
public void testStream() throws Exception {
int written;
//The ByteArrayOutputStream is initialized with 32 bytes to match
//the original more closely for this test.
ByteArrayOutputStream baout = new ByteArrayOutputStream(32);
java.io.ByteArrayOutputStream ref = new java.io.ByteArrayOutputStream();
//First three writes
written = writeData(baout, ref, new int[] {4, 10, 22});
assertEquals(36, written);
checkStreams(baout, ref);
//Another two writes to see if there are any bad effects after toByteArray()
written = writeData(baout, ref, new int[] {20, 12});
assertEquals(32, written);
checkStreams(baout, ref);
//Now reset the streams
baout.reset();
ref.reset();
//Test again to see if reset() had any bad effects
written = writeData(baout, ref, new int[] {5, 47, 33, 60, 1, 0, 8});
assertEquals(155, written);
checkStreams(baout, ref);
//Test the readFrom(InputStream) method
baout.reset();
written = baout.write(new ByteArrayInputStream(ref.toByteArray()));
assertEquals(155, written);
checkStreams(baout, ref);
//Write the commons Byte[]OutputStream to a java.io.Byte[]OutputStream
//and vice-versa to test the writeTo() method.
ByteArrayOutputStream baout1 = new ByteArrayOutputStream(32);
ref.writeTo(baout1);
java.io.ByteArrayOutputStream ref1 = new java.io.ByteArrayOutputStream();
baout.writeTo(ref1);
checkStreams(baout1, ref1);
//Testing toString(String)
String baoutString = baout.toString("ASCII");
String refString = ref.toString("ASCII");
assertEquals("ASCII decoded String must be equal", refString, baoutString);
//Make sure that empty ByteArrayOutputStreams really don't create garbage
//on toByteArray()
assertSame(new ByteArrayOutputStream().toByteArray(),
new ByteArrayOutputStream().toByteArray());
}
}